package com.school.sports.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.school.sports.entity.Report;
import com.school.sports.entity.dto.StatisticsDTO;
import com.school.sports.service.StatisticsService;
import com.school.sports.common.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Positive;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

/**
 * 统计报表控制器
 * 提供各类数据的统计分析和报表生成功能
 */
@RestController
@RequestMapping("/api/statistics")
public class StatisticsController {

    private static final Logger logger = LoggerFactory.getLogger(StatisticsController.class);

    @Autowired
    private StatisticsService statisticsService;

    // ==================== 报名统计接口 ====================

    /**
     * 获取报名统计数据
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 报名统计数据
     */
    @GetMapping("/enrollments")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<StatisticsDTO.EnrollmentStatisticsDTO> getEnrollmentStatistics(
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取报名统计数据，时间范围：{} 至 {}，过滤条件：{}", startTime, endTime, filters);

        try {
            StatisticsDTO.EnrollmentStatisticsDTO statistics = statisticsService.getEnrollmentStatistics(startTime, endTime, filters);
            logger.info("获取报名统计数据成功，总报名数：{}", statistics.getTotalEnrollments());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取报名统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取报名统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取报名趋势数据
     * @param days 统计天数
     * @return 报名趋势数据
     */
    @GetMapping("/enrollments/trend")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<StatisticsDTO.TimeSeriesDataDTO>> getEnrollmentTrend(
            @RequestParam(value = "days", defaultValue = "7") @Positive Integer days) {

        logger.info("获取报名趋势数据，统计天数：{}", days);

        if (days > 365) {
            return Result.fail("统计天数不能超过365天");
        }

        try {
            List<StatisticsDTO.TimeSeriesDataDTO> trend = statisticsService.getEnrollmentTrend(days);
            logger.info("获取报名趋势数据成功，数据点数：{}", trend.size());
            return Result.success(trend);
        } catch (Exception e) {
            logger.error("获取报名趋势数据异常：{}", e.getMessage(), e);
            return Result.fail("获取报名趋势数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目报名排行榜
     * @param limit 排行榜数量限制
     * @return 项目报名排行
     */
    @GetMapping("/enrollments/ranking")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getProjectEnrollmentRanking(
            @RequestParam(value = "limit", defaultValue = "10") @Positive Integer limit) {

        logger.info("获取项目报名排行榜，限制数量：{}", limit);

        if (limit > 100) {
            return Result.fail("排行榜数量不能超过100");
        }

        try {
            List<StatisticsDTO.RankingDataDTO> ranking = statisticsService.getProjectEnrollmentRanking(limit);
            logger.info("获取项目报名排行榜成功，项目数：{}", ranking.size());
            return Result.success(ranking);
        } catch (Exception e) {
            logger.error("获取项目报名排行榜异常：{}", e.getMessage(), e);
            return Result.fail("获取项目报名排行榜失败：" + e.getMessage());
        }
    }

    /**
     * 获取学院报名分布统计
     * @param filters 过滤条件
     * @return 学院报名分布
     */
    @GetMapping("/enrollments/distribution")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Object>> getEnrollmentDistributionByCollege(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取学院报名分布统计，过滤条件：{}", filters);

        try {
            Map<String, Object> distribution = statisticsService.getEnrollmentDistributionByCollege(filters);
            logger.info("获取学院报名分布统计成功，学院数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取学院报名分布统计异常：{}", e.getMessage(), e);
            return Result.fail("获取学院报名分布统计失败：" + e.getMessage());
        }
    }

    // ==================== 成绩统计接口 ====================

    /**
     * 获取成绩统计数据
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 成绩统计数据
     */
    @GetMapping("/scores")
    @PreAuthorize("hasAnyRole('管理员', '老师', '裁判')")
    public Result<StatisticsDTO.ScoreStatisticsDTO> getScoreStatistics(
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取成绩统计数据，时间范围：{} 至 {}，过滤条件：{}", startTime, endTime, filters);

        try {
            StatisticsDTO.ScoreStatisticsDTO statistics = statisticsService.getScoreStatistics(startTime, endTime, filters);
            logger.info("获取成绩统计数据成功，总成绩数：{}", statistics.getTotalScores());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取成绩统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取成绩统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取成绩分布统计
     * @param projectId 项目ID
     * @return 成绩分布数据
     */
    @GetMapping("/scores/distribution")
    @PreAuthorize("hasAnyRole('管理员', '老师', '裁判', '学生')")
    public Result<Map<String, Object>> getScoreDistribution(
            @RequestParam(value = "projectId", required = false) Long projectId) {

        logger.info("获取成绩分布统计，项目ID：{}", projectId);

        try {
            Map<String, Object> distribution = statisticsService.getScoreDistribution(projectId);
            logger.info("获取成绩分布统计成功");
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取成绩分布统计异常：{}", e.getMessage(), e);
            return Result.fail("获取成绩分布统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目平均成绩统计
     * @param filters 过滤条件
     * @return 项目平均成绩
     */
    @GetMapping("/scores/average")
    @PreAuthorize("hasAnyRole('管理员', '老师', '裁判', '学生')")
    public Result<Map<String, Double>> getAverageScoresByProject(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取项目平均成绩统计，过滤条件：{}", filters);

        try {
            Map<String, Double> averageScores = statisticsService.getAverageScoresByProject(filters);
            logger.info("获取项目平均成绩统计成功，项目数：{}", averageScores.size());
            return Result.success(averageScores);
        } catch (Exception e) {
            logger.error("获取项目平均成绩统计异常：{}", e.getMessage(), e);
            return Result.fail("获取项目平均成绩统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取优秀成绩榜单
     * @param projectId 项目ID
     * @param limit 榜单数量限制
     * @return 优秀成绩榜单
     */
    @GetMapping("/scores/top")
    @PreAuthorize("hasAnyRole('管理员', '老师', '裁判', '学生')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getTopPerformers(
            @RequestParam(value = "projectId", required = false) Long projectId,
            @RequestParam(value = "limit", defaultValue = "10") @Positive Integer limit) {

        logger.info("获取优秀成绩榜单，项目ID：{}，限制数量：{}", projectId, limit);

        if (limit > 50) {
            return Result.fail("榜单数量不能超过50");
        }

        try {
            List<StatisticsDTO.RankingDataDTO> topPerformers = statisticsService.getTopPerformers(projectId, limit);
            logger.info("获取优秀成绩榜单成功，人数：{}", topPerformers.size());
            return Result.success(topPerformers);
        } catch (Exception e) {
            logger.error("获取优秀成绩榜单异常：{}", e.getMessage(), e);
            return Result.fail("获取优秀成绩榜单失败：" + e.getMessage());
        }
    }

    // ==================== 项目统计接口 ====================

    /**
     * 获取项目统计数据
     * @param filters 过滤条件
     * @return 项目统计数据
     */
    @GetMapping("/projects")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<StatisticsDTO.ProjectStatisticsDTO> getProjectStatistics(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取项目统计数据，过滤条件：{}", filters);

        try {
            StatisticsDTO.ProjectStatisticsDTO statistics = statisticsService.getProjectStatistics(filters);
            logger.info("获取项目统计数据成功，总项目数：{}", statistics.getTotalProjects());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取项目统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取项目统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目类型分布
     * @return 项目类型分布
     */
    @GetMapping("/projects/types")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<Map<String, Long>> getProjectTypeDistribution() {

        logger.info("获取项目类型分布");

        try {
            Map<String, Long> distribution = statisticsService.getProjectTypeDistribution();
            logger.info("获取项目类型分布成功，类型数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取项目类型分布异常：{}", e.getMessage(), e);
            return Result.fail("获取项目类型分布失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目参与度统计
     * @param filters 过滤条件
     * @return 项目参与度数据
     */
    @GetMapping("/projects/participation")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<Map<String, Object>>> getProjectParticipationRate(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取项目参与度统计，过滤条件：{}", filters);

        try {
            List<Map<String, Object>> participation = statisticsService.getProjectParticipationRate(filters);
            logger.info("获取项目参与度统计成功，项目数：{}", participation.size());
            return Result.success(participation);
        } catch (Exception e) {
            logger.error("获取项目参与度统计异常：{}", e.getMessage(), e);
            return Result.fail("获取项目参与度统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目热度排行榜
     * @param limit 排行榜数量限制
     * @return 项目热度排行
     */
    @GetMapping("/projects/popularity")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getProjectPopularityRanking(
            @RequestParam(value = "limit", defaultValue = "10") @Positive Integer limit) {

        logger.info("获取项目热度排行榜，限制数量：{}", limit);

        if (limit > 50) {
            return Result.fail("排行榜数量不能超过50");
        }

        try {
            List<StatisticsDTO.RankingDataDTO> ranking = statisticsService.getProjectPopularityRanking(limit);
            logger.info("获取项目热度排行榜成功，项目数：{}", ranking.size());
            return Result.success(ranking);
        } catch (Exception e) {
            logger.error("获取项目热度排行榜异常：{}", e.getMessage(), e);
            return Result.fail("获取项目热度排行榜失败：" + e.getMessage());
        }
    }

    // ==================== 用户统计接口 ====================

    /**
     * 获取用户统计数据
     * @param filters 过滤条件
     * @return 用户统计数据
     */
    @GetMapping("/users")
    @PreAuthorize("hasRole('管理员')")
    public Result<StatisticsDTO.UserStatisticsDTO> getUserStatistics(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取用户统计数据，过滤条件：{}", filters);

        try {
            StatisticsDTO.UserStatisticsDTO statistics = statisticsService.getUserStatistics(filters);
            logger.info("获取用户统计数据成功，总用户数：{}", statistics.getTotalUsers());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取用户统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取用户统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取用户角色分布
     * @return 用户角色分布
     */
    @GetMapping("/users/roles")
    @PreAuthorize("hasRole('管理员')")
    public Result<Map<String, Long>> getUserRoleDistribution() {

        logger.info("获取用户角色分布");

        try {
            Map<String, Long> distribution = statisticsService.getUserRoleDistribution();
            logger.info("获取用户角色分布成功，角色数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取用户角色分布异常：{}", e.getMessage(), e);
            return Result.fail("获取用户角色分布失败：" + e.getMessage());
        }
    }

    /**
     * 获取用户注册趋势
     * @param days 统计天数
     * @return 用户注册趋势
     */
    @GetMapping("/users/trend")
    @PreAuthorize("hasRole('管理员')")
    public Result<List<StatisticsDTO.TimeSeriesDataDTO>> getUserRegistrationTrend(
            @RequestParam(value = "days", defaultValue = "30") @Positive Integer days) {

        logger.info("获取用户注册趋势，统计天数：{}", days);

        if (days > 365) {
            return Result.fail("统计天数不能超过365天");
        }

        try {
            List<StatisticsDTO.TimeSeriesDataDTO> trend = statisticsService.getUserRegistrationTrend(days);
            logger.info("获取用户注册趋势成功，数据点数：{}", trend.size());
            return Result.success(trend);
        } catch (Exception e) {
            logger.error("获取用户注册趋势异常：{}", e.getMessage(), e);
            return Result.fail("获取用户注册趋势失败：" + e.getMessage());
        }
    }

    /**
     * 获取学院用户分布
     * @return 学院用户分布
     */
    @GetMapping("/users/colleges")
    @PreAuthorize("hasRole('管理员')")
    public Result<Map<String, Long>> getUserDistributionByCollege() {

        logger.info("获取学院用户分布");

        try {
            Map<String, Long> distribution = statisticsService.getUserDistributionByCollege();
            logger.info("获取学院用户分布成功，学院数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取学院用户分布异常：{}", e.getMessage(), e);
            return Result.fail("获取学院用户分布失败：" + e.getMessage());
        }
    }

    // ==================== 志愿者统计接口 ====================

    /**
     * 获取志愿者统计数据
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 志愿者统计数据
     */
    @GetMapping("/volunteers")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<StatisticsDTO.VolunteerStatisticsDTO> getVolunteerStatistics(
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取志愿者统计数据，时间范围：{} 至 {}，过滤条件：{}", startTime, endTime, filters);

        try {
            StatisticsDTO.VolunteerStatisticsDTO statistics = statisticsService.getVolunteerStatistics(startTime, endTime, filters);
            logger.info("获取志愿者统计数据成功，总志愿者数：{}", statistics.getTotalVolunteers());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取志愿者统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取志愿者统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取志愿者服务时长统计
     * @param days 统计天数
     * @return 服务时长统计
     */
    @GetMapping("/volunteers/hours")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<StatisticsDTO.TimeSeriesDataDTO>> getVolunteerServiceHoursTrend(
            @RequestParam(value = "days", defaultValue = "7") @Positive Integer days) {

        logger.info("获取志愿者服务时长统计，统计天数：{}", days);

        if (days > 90) {
            return Result.fail("统计天数不能超过90天");
        }

        try {
            List<StatisticsDTO.TimeSeriesDataDTO> trend = statisticsService.getVolunteerServiceHoursTrend(days);
            logger.info("获取志愿者服务时长统计成功，数据点数：{}", trend.size());
            return Result.success(trend);
        } catch (Exception e) {
            logger.error("获取志愿者服务时长统计异常：{}", e.getMessage(), e);
            return Result.fail("获取志愿者服务时长统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取志愿者服务排行榜
     * @param limit 排行榜数量限制
     * @return 志愿者服务排行
     */
    @GetMapping("/volunteers/ranking")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getVolunteerServiceRanking(
            @RequestParam(value = "limit", defaultValue = "10") @Positive Integer limit) {

        logger.info("获取志愿者服务排行榜，限制数量：{}", limit);

        if (limit > 50) {
            return Result.fail("排行榜数量不能超过50");
        }

        try {
            List<StatisticsDTO.RankingDataDTO> ranking = statisticsService.getVolunteerServiceRanking(limit);
            logger.info("获取志愿者服务排行榜成功，志愿者数：{}", ranking.size());
            return Result.success(ranking);
        } catch (Exception e) {
            logger.error("获取志愿者服务排行榜异常：{}", e.getMessage(), e);
            return Result.fail("获取志愿者服务排行榜失败：" + e.getMessage());
        }
    }

    /**
     * 获取志愿者部门分布
     * @return 志愿者部门分布
     */
    @GetMapping("/volunteers/departments")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Long>> getVolunteerDistributionByDepartment() {

        logger.info("获取志愿者部门分布");

        try {
            Map<String, Long> distribution = statisticsService.getVolunteerDistributionByDepartment();
            logger.info("获取志愿者部门分布成功，部门数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取志愿者部门分布异常：{}", e.getMessage(), e);
            return Result.fail("获取志愿者部门分布失败：" + e.getMessage());
        }
    }

    // ==================== 裁判统计接口 ====================

    /**
     * 获取裁判统计数据
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 裁判统计数据
     */
    @GetMapping("/referees")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<StatisticsDTO.RefereeStatisticsDTO> getRefereeStatistics(
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取裁判统计数据，时间范围：{} 至 {}，过滤条件：{}", startTime, endTime, filters);

        try {
            StatisticsDTO.RefereeStatisticsDTO statistics = statisticsService.getRefereeStatistics(startTime, endTime, filters);
            logger.info("获取裁判统计数据成功，总裁判数：{}", statistics.getTotalReferees());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取裁判统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取裁判统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取裁判工作量统计
     * @param filters 过滤条件
     * @return 裁判工作量数据
     */
    @GetMapping("/referees/workload")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<Map<String, Object>>> getRefereeWorkloadStatistics(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取裁判工作量统计，过滤条件：{}", filters);

        try {
            List<Map<String, Object>> workload = statisticsService.getRefereeWorkloadStatistics(filters);
            logger.info("获取裁判工作量统计成功，裁判数：{}", workload.size());
            return Result.success(workload);
        } catch (Exception e) {
            logger.error("获取裁判工作量统计异常：{}", e.getMessage(), e);
            return Result.fail("获取裁判工作量统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取裁判专业分布
     * @return 裁判专业分布
     */
    @GetMapping("/referees/specialties")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Long>> getRefereeDistributionBySpecialty() {

        logger.info("获取裁判专业分布");

        try {
            Map<String, Long> distribution = statisticsService.getRefereeDistributionBySpecialty();
            logger.info("获取裁判专业分布成功，专业数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取裁判专业分布异常：{}", e.getMessage(), e);
            return Result.fail("获取裁判专业分布失败：" + e.getMessage());
        }
    }

    /**
     * 获取裁判等级分布
     * @return 裁判等级分布
     */
    @GetMapping("/referees/levels")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Long>> getRefereeDistributionByLevel() {

        logger.info("获取裁判等级分布");

        try {
            Map<String, Long> distribution = statisticsService.getRefereeDistributionByLevel();
            logger.info("获取裁判等级分布成功，等级数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取裁判等级分布异常：{}", e.getMessage(), e);
            return Result.fail("获取裁判等级分布失败：" + e.getMessage());
        }
    }

    // ==================== 奖牌统计接口 ====================

    /**
     * 获取奖牌统计数据
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 奖牌统计数据
     */
    @GetMapping("/awards")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<StatisticsDTO.MedalStatisticsDTO> getMedalStatistics(
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取奖牌统计数据，时间范围：{} 至 {}，过滤条件：{}", startTime, endTime, filters);

        try {
            StatisticsDTO.MedalStatisticsDTO statistics = statisticsService.getMedalStatistics(startTime, endTime, filters);
            logger.info("获取奖牌统计数据成功，总奖牌数：{}", statistics.getTotalAwards());
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取奖牌统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取奖牌统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取学院奖牌排行榜
     * @param filters 过滤条件
     * @return 学院奖牌排行
     */
    @GetMapping("/awards/colleges")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getCollegeMedalRanking(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取学院奖牌排行榜，过滤条件：{}", filters);

        try {
            List<StatisticsDTO.RankingDataDTO> ranking = statisticsService.getCollegeMedalRanking(filters);
            logger.info("获取学院奖牌排行榜成功，学院数：{}", ranking.size());
            return Result.success(ranking);
        } catch (Exception e) {
            logger.error("获取学院奖牌排行榜异常：{}", e.getMessage(), e);
            return Result.fail("获取学院奖牌排行榜失败：" + e.getMessage());
        }
    }

    /**
     * 获取班级奖牌排行榜
     * @param filters 过滤条件
     * @return 班级奖牌排行
     */
    @GetMapping("/awards/classes")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<List<StatisticsDTO.RankingDataDTO>> getClassMedalRanking(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取班级奖牌排行榜，过滤条件：{}", filters);

        try {
            List<StatisticsDTO.RankingDataDTO> ranking = statisticsService.getClassMedalRanking(filters);
            logger.info("获取班级奖牌排行榜成功，班级数：{}", ranking.size());
            return Result.success(ranking);
        } catch (Exception e) {
            logger.error("获取班级奖牌排行榜异常：{}", e.getMessage(), e);
            return Result.fail("获取班级奖牌排行榜失败：" + e.getMessage());
        }
    }

    /**
     * 获取项目奖牌分布
     * @return 项目奖牌分布
     */
    @GetMapping("/awards/projects")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生')")
    public Result<Map<String, Map<String, Long>>> getMedalDistributionByProject() {

        logger.info("获取项目奖牌分布");

        try {
            Map<String, Map<String, Long>> distribution = statisticsService.getMedalDistributionByProject();
            logger.info("获取项目奖牌分布成功，项目数：{}", distribution.size());
            return Result.success(distribution);
        } catch (Exception e) {
            logger.error("获取项目奖牌分布异常：{}", e.getMessage(), e);
            return Result.fail("获取项目奖牌分布失败：" + e.getMessage());
        }
    }

    // ==================== 总体统计接口 ====================

    /**
     * 获取总体统计数据
     * @param filters 过滤条件
     * @return 总体统计数据
     */
    @GetMapping("/overview")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<StatisticsDTO.OverviewStatisticsDTO> getOverviewStatistics(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取总体统计数据，过滤条件：{}", filters);

        try {
            StatisticsDTO.OverviewStatisticsDTO statistics = statisticsService.getOverviewStatistics(filters);
            logger.info("获取总体统计数据成功");
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取总体统计数据异常：{}", e.getMessage(), e);
            return Result.fail("获取总体统计数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取运动会实时数据
     * @return 实时数据
     */
    @GetMapping("/realtime")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '志愿者', '裁判')")
    public Result<Map<String, Object>> getRealTimeStatistics() {

        logger.info("获取运动会实时数据");

        try {
            Map<String, Object> statistics = statisticsService.getRealTimeStatistics();
            logger.info("获取运动会实时数据成功");
            return Result.success(statistics);
        } catch (Exception e) {
            logger.error("获取运动会实时数据异常：{}", e.getMessage(), e);
            return Result.fail("获取运动会实时数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取每日活动总结
     * @param days 统计天数
     * @return 每日活动数据
     */
    @GetMapping("/daily")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<Map<String, Object>>> getDailyActivitySummary(
            @RequestParam(value = "days", defaultValue = "7") @Positive Integer days) {

        logger.info("获取每日活动总结，统计天数：{}", days);

        if (days > 30) {
            return Result.fail("统计天数不能超过30天");
        }

        try {
            List<Map<String, Object>> summary = statisticsService.getDailyActivitySummary(days);
            logger.info("获取每日活动总结成功，天数：{}", summary.size());
            return Result.success(summary);
        } catch (Exception e) {
            logger.error("获取每日活动总结异常：{}", e.getMessage(), e);
            return Result.fail("获取每日活动总结失败：" + e.getMessage());
        }
    }

    /**
     * 获取参与率统计
     * @param filters 过滤条件
     * @return 参与率数据
     */
    @GetMapping("/participation")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Double>> getParticipationRates(
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("获取参与率统计，过滤条件：{}", filters);

        try {
            Map<String, Double> rates = statisticsService.getParticipationRates(filters);
            logger.info("获取参与率统计成功，指标数：{}", rates.size());
            return Result.success(rates);
        } catch (Exception e) {
            logger.error("获取参与率统计异常：{}", e.getMessage(), e);
            return Result.fail("获取参与率统计失败：" + e.getMessage());
        }
    }

    // ==================== 报表生成和管理接口 ====================

    /**
     * 生成统计报表
     * @param reportType 报表类型
     * @param reportName 报表名称
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 报表对象
     */
    @PostMapping("/reports")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Report> generateReport(
            @RequestParam("reportType") @NotBlank String reportType,
            @RequestParam("reportName") @NotBlank String reportName,
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("生成统计报表，类型：{}，名称：{}，时间范围：{} 至 {}", reportType, reportName, startTime, endTime);

        try {
            // 获取当前用户ID（实际项目中应该从Spring Security上下文中获取）
            Long currentUserId = 1L; // 暂时硬编码

            Report report = statisticsService.generateReport(reportType, reportName, startTime, endTime, filters, currentUserId);
            logger.info("生成统计报表成功，报表ID：{}", report.getId());
            return Result.success(report);
        } catch (Exception e) {
            logger.error("生成统计报表异常：{}", e.getMessage(), e);
            return Result.fail("生成统计报表失败：" + e.getMessage());
        }
    }

    /**
     * 异步生成报表
     * @param reportType 报表类型
     * @param reportName 报表名称
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param filters 过滤条件
     * @return 报表ID
     */
    @PostMapping("/reports/async")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Long> generateReportAsync(
            @RequestParam("reportType") @NotBlank String reportType,
            @RequestParam("reportName") @NotBlank String reportName,
            @RequestParam(value = "startTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(value = "endTime", required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("异步生成统计报表，类型：{}，名称：{}，时间范围：{} 至 {}", reportType, reportName, startTime, endTime);

        try {
            // 获取当前用户ID（实际项目中应该从Spring Security上下文中获取）
            Long currentUserId = 1L; // 暂时硬编码

            Long reportId = statisticsService.generateReportAsync(reportType, reportName, startTime, endTime, filters, currentUserId);
            logger.info("异步生成统计报表任务已提交，报表ID：{}", reportId);
            return Result.success(reportId);
        } catch (Exception e) {
            logger.error("异步生成统计报表异常：{}", e.getMessage(), e);
            return Result.fail("异步生成统计报表失败：" + e.getMessage());
        }
    }

    /**
     * 分页查询报表列表
     * @param currentPage 当前页码
     * @param pageSize 每页大小
     * @param filters 过滤条件
     * @return 报表分页数据
     */
    @GetMapping("/reports/page/{currentPage}/{pageSize}")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<IPage<Report>> getReportPage(
            @PathVariable("currentPage") @Positive Integer currentPage,
            @PathVariable("pageSize") @Positive Integer pageSize,
            @RequestParam(value = "filters", required = false) Map<String, Object> filters) {

        logger.info("分页查询报表列表，当前页码：{}，每页条数：{}，过滤条件：{}", currentPage, pageSize, filters);

        // 参数校验
        if (currentPage == null || currentPage <= 0) {
            currentPage = 1;
        }
        if (pageSize == null || pageSize <= 0 || pageSize > 100) {
            pageSize = 10;
        }

        try {
            IPage<Report> page = statisticsService.getReportPage(currentPage, pageSize, filters);
            logger.info("查询报表列表成功，共{}条记录", page.getTotal());
            return Result.success(page);
        } catch (Exception e) {
            logger.error("查询报表列表异常：{}", e.getMessage(), e);
            return Result.fail("查询报表列表失败：" + e.getMessage());
        }
    }

    /**
     * 根据ID查询报表详情
     * @param reportId 报表ID
     * @return 报表详情
     */
    @GetMapping("/reports/{reportId}")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Report> getReportById(@PathVariable("reportId") @NotNull Long reportId) {
        logger.info("查询报表详情，报表ID：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            Report report = statisticsService.getReportById(reportId);
            if (report == null) {
                return Result.fail("报表不存在");
            }
            logger.info("查询报表详情成功，报表名称：{}", report.getReportName());
            return Result.success(report);
        } catch (Exception e) {
            logger.error("查询报表详情异常：{}", e.getMessage(), e);
            return Result.fail("查询报表详情失败：" + e.getMessage());
        }
    }

    /**
     * 更新报表状态
     * @param reportId 报表ID
     * @param status 新状态
     * @return 更新结果
     */
    @PutMapping("/reports/{reportId}/status")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> updateReportStatus(
            @PathVariable("reportId") @NotNull Long reportId,
            @RequestParam("status") @NotBlank String status) {

        logger.info("更新报表状态：{} -> {}", reportId, status);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            boolean success = statisticsService.updateReportStatus(reportId, status);
            if (success) {
                logger.info("更新报表状态成功：{}", reportId);
                return Result.success("状态更新成功");
            } else {
                return Result.fail("状态更新失败");
            }
        } catch (Exception e) {
            logger.error("更新报表状态异常：{}", e.getMessage(), e);
            return Result.fail("状态更新失败：" + e.getMessage());
        }
    }

    /**
     * 删除报表
     * @param reportId 报表ID
     * @return 删除结果
     */
    @DeleteMapping("/reports/{reportId}")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> deleteReport(@PathVariable("reportId") @NotNull Long reportId) {
        logger.info("删除报表：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            boolean success = statisticsService.deleteReport(reportId);
            if (success) {
                logger.info("删除报表成功：{}", reportId);
                return Result.success("删除成功");
            } else {
                return Result.fail("删除失败");
            }
        } catch (Exception e) {
            logger.error("删除报表异常：{}", e.getMessage(), e);
            return Result.fail("删除失败：" + e.getMessage());
        }
    }

    /**
     * 批量删除报表
     * @param reportIds 报表ID列表
     * @return 删除结果
     */
    @DeleteMapping("/reports/batch")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> batchDeleteReports(@RequestBody List<Long> reportIds) {
        logger.info("批量删除报表：{}", reportIds);

        if (reportIds == null || reportIds.isEmpty()) {
            return Result.fail("请选择要删除的报表");
        }

        try {
            boolean success = statisticsService.batchDeleteReports(reportIds);
            if (success) {
                logger.info("批量删除报表成功，共{}个报表", reportIds.size());
                return Result.success("批量删除成功");
            } else {
                return Result.fail("批量删除失败");
            }
        } catch (Exception e) {
            logger.error("批量删除报表异常：{}", e.getMessage(), e);
            return Result.fail("批量删除失败：" + e.getMessage());
        }
    }

    /**
     * 刷新报表数据
     * @param reportId 报表ID
     * @return 刷新结果
     */
    @PutMapping("/reports/{reportId}/refresh")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> refreshReport(@PathVariable("reportId") @NotNull Long reportId) {
        logger.info("刷新报表数据：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            boolean success = statisticsService.refreshReport(reportId);
            if (success) {
                logger.info("刷新报表数据成功：{}", reportId);
                return Result.success("刷新成功");
            } else {
                return Result.fail("刷新失败");
            }
        } catch (Exception e) {
            logger.error("刷新报表数据异常：{}", e.getMessage(), e);
            return Result.fail("刷新失败：" + e.getMessage());
        }
    }

    /**
     * 检查报表生成状态
     * @param reportId 报表ID
     * @return 生成状态
     */
    @GetMapping("/reports/{reportId}/status")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> checkReportGenerationStatus(@PathVariable("reportId") @NotNull Long reportId) {
        logger.info("检查报表生成状态：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            String status = statisticsService.checkReportGenerationStatus(reportId);
            logger.info("检查报表生成状态成功，状态：{}", status);
            return Result.success(status);
        } catch (Exception e) {
            logger.error("检查报表生成状态异常：{}", e.getMessage(), e);
            return Result.fail("检查报表生成状态失败：" + e.getMessage());
        }
    }

    // ==================== 报表导出接口 ====================

    /**
     * 导出报表为Excel
     * @param reportId 报表ID
     * @param config 导出配置
     * @return 文件路径
     */
    @PostMapping("/reports/{reportId}/export/excel")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> exportReportToExcel(
            @PathVariable("reportId") @NotNull Long reportId,
            @RequestBody @Valid StatisticsDTO.ExportConfigDTO config) {

        logger.info("导出报表为Excel，报表ID：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            String filePath = statisticsService.exportReportToExcel(reportId, config);
            logger.info("导出报表为Excel成功，文件路径：{}", filePath);
            return Result.success(filePath);
        } catch (Exception e) {
            logger.error("导出报表为Excel异常：{}", e.getMessage(), e);
            return Result.fail("导出报表为Excel失败：" + e.getMessage());
        }
    }

    /**
     * 导出报表为PDF
     * @param reportId 报表ID
     * @param config 导出配置
     * @return 文件路径
     */
    @PostMapping("/reports/{reportId}/export/pdf")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> exportReportToPDF(
            @PathVariable("reportId") @NotNull Long reportId,
            @RequestBody @Valid StatisticsDTO.ExportConfigDTO config) {

        logger.info("导出报表为PDF，报表ID：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            String filePath = statisticsService.exportReportToPDF(reportId, config);
            logger.info("导出报表为PDF成功，文件路径：{}", filePath);
            return Result.success(filePath);
        } catch (Exception e) {
            logger.error("导出报表为PDF异常：{}", e.getMessage(), e);
            return Result.fail("导出报表为PDF失败：" + e.getMessage());
        }
    }

    /**
     * 导出报表为Word
     * @param reportId 报表ID
     * @param config 导出配置
     * @return 文件路径
     */
    @PostMapping("/reports/{reportId}/export/word")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> exportReportToWord(
            @PathVariable("reportId") @NotNull Long reportId,
            @RequestBody @Valid StatisticsDTO.ExportConfigDTO config) {

        logger.info("导出报表为Word，报表ID：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            String filePath = statisticsService.exportReportToWord(reportId, config);
            logger.info("导出报表为Word成功，文件路径：{}", filePath);
            return Result.success(filePath);
        } catch (Exception e) {
            logger.error("导出报表为Word异常：{}", e.getMessage(), e);
            return Result.fail("导出报表为Word失败：" + e.getMessage());
        }
    }

    /**
     * 导出报表为CSV
     * @param reportId 报表ID
     * @param config 导出配置
     * @return 文件路径
     */
    @PostMapping("/reports/{reportId}/export/csv")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<String> exportReportToCSV(
            @PathVariable("reportId") @NotNull Long reportId,
            @RequestBody @Valid StatisticsDTO.ExportConfigDTO config) {

        logger.info("导出报表为CSV，报表ID：{}", reportId);

        if (reportId == null || reportId <= 0) {
            return Result.fail("报表ID无效");
        }

        try {
            String filePath = statisticsService.exportReportToCSV(reportId, config);
            logger.info("导出报表为CSV成功，文件路径：{}", filePath);
            return Result.success(filePath);
        } catch (Exception e) {
            logger.error("导出报表为CSV异常：{}", e.getMessage(), e);
            return Result.fail("导出报表为CSV失败：" + e.getMessage());
        }
    }

    // ==================== 图表数据生成接口 ====================

    /**
     * 生成图表配置
     * @param chartType 图表类型
     * @param data 数据
     * @param options 图表选项
     * @return 图表配置
     */
    @PostMapping("/charts")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '志愿者', '裁判')")
    public Result<StatisticsDTO.ChartConfigDTO> generateChartConfig(
            @RequestParam("chartType") @NotBlank String chartType,
            @RequestBody List<Map<String, Object>> data,
            @RequestParam(value = "options", required = false) Map<String, Object> options) {

        logger.info("生成图表配置，图表类型：{}，数据量：{}", chartType, data.size());

        try {
            StatisticsDTO.ChartConfigDTO config = statisticsService.generateChartConfig(chartType, data, options);
            logger.info("生成图表配置成功");
            return Result.success(config);
        } catch (Exception e) {
            logger.error("生成图表配置异常：{}", e.getMessage(), e);
            return Result.fail("生成图表配置失败：" + e.getMessage());
        }
    }

    /**
     * 获取仪表盘数据
     * @return 仪表盘数据
     */
    @GetMapping("/dashboard")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '志愿者', '裁判')")
    public Result<Map<String, Object>> getDashboardData() {

        logger.info("获取仪表盘数据");

        try {
            Map<String, Object> dashboardData = statisticsService.getDashboardData();
            logger.info("获取仪表盘数据成功");
            return Result.success(dashboardData);
        } catch (Exception e) {
            logger.error("获取仪表盘数据异常：{}", e.getMessage(), e);
            return Result.fail("获取仪表盘数据失败：" + e.getMessage());
        }
    }

    /**
     * 获取实时图表数据
     * @param dataType 数据类型
     * @param timeRange 时间范围
     * @return 实时图表数据
     */
    @GetMapping("/charts/realtime")
    @PreAuthorize("hasAnyRole('管理员', '老师', '学生', '志愿者', '裁判')")
    public Result<List<Map<String, Object>>> getRealTimeChartData(
            @RequestParam("dataType") @NotBlank String dataType,
            @RequestParam(value = "timeRange", defaultValue = "1h") String timeRange) {

        logger.info("获取实时图表数据，数据类型：{}，时间范围：{}", dataType, timeRange);

        try {
            List<Map<String, Object>> chartData = statisticsService.getRealTimeChartData(dataType, timeRange);
            logger.info("获取实时图表数据成功，数据点数：{}", chartData.size());
            return Result.success(chartData);
        } catch (Exception e) {
            logger.error("获取实时图表数据异常：{}", e.getMessage(), e);
            return Result.fail("获取实时图表数据失败：" + e.getMessage());
        }
    }

    // ==================== 数据缓存管理接口 ====================

    /**
     * 清除统计数据缓存
     * @param cacheKey 缓存键
     * @return 清除结果
     */
    @DeleteMapping("/cache/{cacheKey}")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> clearStatisticsCache(@PathVariable("cacheKey") @NotBlank String cacheKey) {
        logger.info("清除统计数据缓存：{}", cacheKey);

        try {
            statisticsService.clearStatisticsCache(cacheKey);
            logger.info("清除统计数据缓存成功：{}", cacheKey);
            return Result.success("缓存清除成功");
        } catch (Exception e) {
            logger.error("清除统计数据缓存异常：{}", e.getMessage(), e);
            return Result.fail("清除缓存失败：" + e.getMessage());
        }
    }

    /**
     * 清除所有统计数据缓存
     * @return 清除结果
     */
    @DeleteMapping("/cache/all")
    @PreAuthorize("hasRole('管理员')")
    public Result<String> clearAllStatisticsCache() {
        logger.info("清除所有统计数据缓存");

        try {
            statisticsService.clearAllStatisticsCache();
            logger.info("清除所有统计数据缓存成功");
            return Result.success("所有缓存清除成功");
        } catch (Exception e) {
            logger.error("清除所有统计数据缓存异常：{}", e.getMessage(), e);
            return Result.fail("清除所有缓存失败：" + e.getMessage());
        }
    }

    // ==================== 系统监控接口 ====================

    /**
     * 获取系统性能统计
     * @return 系统性能数据
     */
    @GetMapping("/system/performance")
    @PreAuthorize("hasRole('管理员')")
    public Result<Map<String, Object>> getSystemPerformanceStatistics() {

        logger.info("获取系统性能统计");

        try {
            Map<String, Object> performance = statisticsService.getSystemPerformanceStatistics();
            logger.info("获取系统性能统计成功");
            return Result.success(performance);
        } catch (Exception e) {
            logger.error("获取系统性能统计异常：{}", e.getMessage(), e);
            return Result.fail("获取系统性能统计失败：" + e.getMessage());
        }
    }

    /**
     * 获取数据质量报告
     * @return 数据质量报告
     */
    @GetMapping("/system/quality")
    @PreAuthorize("hasRole('管理员')")
    public Result<Map<String, Object>> getDataQualityReport() {

        logger.info("获取数据质量报告");

        try {
            Map<String, Object> qualityReport = statisticsService.getDataQualityReport();
            logger.info("获取数据质量报告成功");
            return Result.success(qualityReport);
        } catch (Exception e) {
            logger.error("获取数据质量报告异常：{}", e.getMessage(), e);
            return Result.fail("获取数据质量报告失败：" + e.getMessage());
        }
    }

    /**
     * 获取异常数据报告
     * @return 异常数据报告
     */
    @GetMapping("/system/abnormal")
    @PreAuthorize("hasRole('管理员')")
    public Result<List<Map<String, Object>>> getAbnormalDataReport() {

        logger.info("获取异常数据报告");

        try {
            List<Map<String, Object>> abnormalData = statisticsService.getAbnormalDataReport();
            logger.info("获取异常数据报告成功，异常数：{}", abnormalData.size());
            return Result.success(abnormalData);
        } catch (Exception e) {
            logger.error("获取异常数据报告异常：{}", e.getMessage(), e);
            return Result.fail("获取异常数据报告失败：" + e.getMessage());
        }
    }

    // ==================== 数据分析接口 ====================

    /**
     * 获取数据趋势分析
     * @param dataType 数据类型
     * @param timeRange 时间范围
     * @return 趋势分析结果
     */
    @GetMapping("/analysis/trend")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Object>> getDataTrendAnalysis(
            @RequestParam("dataType") @NotBlank String dataType,
            @RequestParam("timeRange") @NotBlank String timeRange) {

        logger.info("获取数据趋势分析，数据类型：{}，时间范围：{}", dataType, timeRange);

        try {
            Map<String, Object> analysis = statisticsService.getDataTrendAnalysis(dataType, timeRange);
            logger.info("获取数据趋势分析成功");
            return Result.success(analysis);
        } catch (Exception e) {
            logger.error("获取数据趋势分析异常：{}", e.getMessage(), e);
            return Result.fail("获取数据趋势分析失败：" + e.getMessage());
        }
    }

    /**
     * 获取数据对比分析
     * @param currentPeriod 当前周期配置
     * @param previousPeriod 前一周期配置
     * @param dataType 数据类型
     * @return 对比分析结果
     */
    @PostMapping("/analysis/comparison")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<Map<String, Object>> getDataComparisonAnalysis(
            @RequestBody Map<String, Object> currentPeriod,
            @RequestBody Map<String, Object> previousPeriod,
            @RequestParam("dataType") @NotBlank String dataType) {

        logger.info("获取数据对比分析，数据类型：{}", dataType);

        try {
            Map<String, Object> analysis = statisticsService.getDataComparisonAnalysis(currentPeriod, previousPeriod, dataType);
            logger.info("获取数据对比分析成功");
            return Result.success(analysis);
        } catch (Exception e) {
            logger.error("获取数据对比分析异常：{}", e.getMessage(), e);
            return Result.fail("获取数据对比分析失败：" + e.getMessage());
        }
    }

    /**
     * 获取预测数据
     * @param dataType 数据类型
     * @param period 预测周期
     * @return 预测数据
     */
    @GetMapping("/analysis/prediction")
    @PreAuthorize("hasAnyRole('管理员', '老师')")
    public Result<List<StatisticsDTO.TimeSeriesDataDTO>> getPredictionData(
            @RequestParam("dataType") @NotBlank String dataType,
            @RequestParam("period") @Positive Integer period) {

        logger.info("获取预测数据，数据类型：{}，预测周期：{}", dataType, period);

        if (period > 365) {
            return Result.fail("预测周期不能超过365天");
        }

        try {
            List<StatisticsDTO.TimeSeriesDataDTO> prediction = statisticsService.getPredictionData(dataType, period);
            logger.info("获取预测数据成功，预测点数：{}", prediction.size());
            return Result.success(prediction);
        } catch (Exception e) {
            logger.error("获取预测数据异常：{}", e.getMessage(), e);
            return Result.fail("获取预测数据失败：" + e.getMessage());
        }
    }
}